#include <bits/stdc++.h>
using namespace std;
using ll = long long;
static const int MOD = 1000000007;

// 快速幂：计算 base^exp mod MOD
ll modpow(ll base, ll exp) {
    ll ans = 1 % MOD;
    base %= MOD;
    while (exp > 0) {
        if (exp & 1) ans = (ans * base) % MOD;
        base = (base * base) % MOD;
        exp >>= 1;
    }
    return ans;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    // 1) 读入树的边，构造邻接表
    vector<vector<int>> adj(n);
    for(int i = 0; i < n-1; i++){
        int x, y;
        cin >> x >> y;
        // 输入保证 0 <= x,y < n
        adj[x].push_back(y);
        adj[y].push_back(x);
    }

    // 2) BFS 从根 0 开始，计算每个节点在树 T 中的深度 d[v]
    vector<int> depth(n, -1);
    queue<int> q;
    depth[0] = 0;
    q.push(0);
    while(!q.empty()){
        int u = q.front(); 
        q.pop();
        for(int v : adj[u]){
            if(depth[v] == -1){
                depth[v] = depth[u] + 1;
                q.push(v);
            }
        }
    }

    // 3) 统计各深度层上节点的数量 c[k]
    int maxd = 0;
    for(int i = 0; i < n; i++){
        if(depth[i] > maxd) 
            maxd = depth[i];
    }
    vector<ll> cnt(maxd+1, 0LL);
    for(int i = 0; i < n; i++){
        cnt[ depth[i] ]++;
    }
    // c[k] = cnt[k]

    // 4) 计算 M_all = sum_k C(c[k],2) + sum_{k=1..maxd} c[k-1]*c[k]
    ll M_all = 0;
    // 4.1 同一深度内部的横向边
    for(int k = 0; k <= maxd; k++){
        ll c = cnt[k];
        M_all += (c * (c - 1)) / 2; 
        // 这里 (c*(c-1))/2 不超过 ~5e11，ll 足够
    }
    // 4.2 相邻深度之间的纵向边
    for(int k = 1; k <= maxd; k++){
        M_all += cnt[k-1] * cnt[k];
    }

    // 5) 去掉 n-1 条“树边”后，剩下 M_free = M_all - (n-1)
    ll M_free = M_all - ( (ll)n - 1LL );

    // 6) 答案 = 2^{M_free} mod (1e9+7)
    ll ans = modpow(2LL, M_free);
    cout << ans << "\n";
    return 0;
}
